%load_ext pretty_jupyter

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt


from sklearn.metrics import confusion_matrix

# confusion_matrix, accuracy_score, precision_score, 
#   recall_score, f1_score: Funções do scikit-learn 
#   para calcular métricas de desempenho.
from sklearn.metrics import confusion_matrix, accuracy_score, precision_score, recall_score, f1_score
from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import BaggingClassifier
import time
from tqdm import tqdm
from sklearn.base import clone

from sklearn.decomposition import TruncatedSVD
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.preprocessing import StandardScaler

import joblib

catalago = pd.read_pickle("C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/3.Datasets_Transformação/3.3_Datasets_Transformação_parte_3/catalogo.pickle", compression='gzip')

# Dados de treino
knn_filmes_treino = pd.read_pickle("C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/3.Datasets_Transformação/3.3_Datasets_Transformação_parte_3/knn_filmes_treino.pickle", compression='gzip')

# Dados de teste
knn_filmes_teste = pd.read_pickle("C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/3.Datasets_Transformação/3.3_Datasets_Transformação_parte_3/knn_filmes_teste.pickle", compression='gzip')

# Olhar tabela de treino para modelagem 1: Filmes
knn_filmes_treino

# Olhar tabela de teste para modelagem 1: Filmes
knn_filmes_teste

# Aplicar SVD
n_components = 20  
svd = TruncatedSVD(n_components=n_components) # Reduzir a dimensionalidade
latent_matrix = svd.fit_transform(knn_filmes_treino) # Treinar o SVD
latent_matrix_transpose = svd.components_

# Reconstruir a matriz de avaliações aproximada
reconstructed_matrix = np.dot(latent_matrix, latent_matrix_transpose)

# Similaridade entre usuários
user_similarity = cosine_similarity(latent_matrix)

user_similarity

knn_filmes_teste.value_counts().sum()

# Exemplo de função ajustada para usar .iloc se knn_filmes_teste é um DataFrame do Pandas
def predict_rating(user_index, item_index, user_similarity, knn_filmes_teste, knn_filmes_treino):
    # Se o usuário já avaliou o filme, retorna a avaliação real
    if knn_filmes_teste.iloc[user_index, item_index] != 0:
        return knn_filmes_teste.iloc[user_index, item_index]
    
    # Calcula a previsão com base na similaridade entre usuários
    predicted_rating = np.dot(user_similarity[user_index], knn_filmes_treino.iloc[:, item_index]) / np.sum(user_similarity[user_index])
    
    return predicted_rating

# Exemplo de uso
user_index = 128
item_index = 3

predicted_rating = predict_rating(user_index, item_index, user_similarity, knn_filmes_teste, knn_filmes_treino)
print(f"Predicted rating for user {user_index} on item {item_index}: {predicted_rating}")

def predict_all_ratings(user_similarity, knn_filmes_teste, knn_filmes_treino):
    predicted_ratings = knn_filmes_teste.copy()  # Copia o DataFrame knn_filmes_teste para armazenar as previsões
    
    for user_index in range(knn_filmes_teste.shape[0]):
        # Encontra os índices dos filmes não avaliados pelo usuário atual
        unrated_indices = np.where(knn_filmes_teste.iloc[user_index, :] == 0)[0]
        
        # Calcula as previsões para os filmes não avaliados
        if len(unrated_indices) > 0:
            user_sim = user_similarity[user_index]
            knn_treino_subset = knn_filmes_treino.iloc[:, unrated_indices]
            predicted_ratings.iloc[user_index, unrated_indices] = np.dot(user_sim, knn_treino_subset) / np.sum(user_sim)
    
    return predicted_ratings

from tqdm import tqdm
import time

# Número total de iterações
total_iterations = 100

# Uso do tqdm para criar a barra de progresso
for i in tqdm(range(total_iterations)):
    # Simulação de trabalho
    #time.sleep(0.1)  # Aqui você substitui pelo seu trecho de código
    # Chamada da função para prever todas as avaliações
    predicted_ratings_df = predict_all_ratings(user_similarity, knn_filmes_teste, knn_filmes_treino)


# Ao finalizar, a barra de progresso será completa
print("Execução completa!")

# Tabela com as recomendações para todos os usuários
predicted_ratings_df

# Salvar tabela predicted_ratings_df
predicted_ratings_df.to_pickle("C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/6.Modelagem_SVD/predicted_ratings_df.pickle", compression="gzip")

n_recomendacoes = 3

# Função para encontrar os top N filmes recomendados para um usuário
def top_recomendacoes(row, n) -> list:
    ''' Função que encontra as melhores recomendações para cada userId
    Args:
      - row = linha do DataFrame. 
              Cada linha representa as recomendações de filme para cada userId.
      - n = número de filmes a serem recomendados 

    Return:
      - Retorna uma lista com os "n" valores mais altos em cada. 
       Ou seja, retorna com as "n" recomendações de filmes.      
    '''
    # Selecionar e retornar os "n" valores mais altos de cada linha
    return row.nlargest(n).index.tolist()

    #OBS: .index(): Obtemos os nomes dos filmes, ao invés dos valores.
    #     .tolist(): Criamos uma lista com os nomes dos filmes 

# Aplicar a função a cada linha do DataFrame de previsões
recomendacoes = predicted_ratings_df.apply(top_recomendacoes, n=n_recomendacoes, axis=1) 

# OBS: apply(... axis=1) -> Aplicar em cada linha
#      n = número de recomendações

recomendacoes

# Criar um DataFrame para armazenar as recomendações
df_recomendacoes = pd.DataFrame(recomendacoes.tolist(), index=recomendacoes.index, columns=[f"recomendação_{i+1}" for i in range(n_recomendacoes)])
# Transformar o userId em coluna
df_recomendacoes = df_recomendacoes.reset_index()
df_recomendacoes

df_recomendacoes.isna().sum()

def assistiu_ou_nao(row, df_teste):
    # Obtém as recomendações para o usuário atual
    recomendacoes = row.drop('userId').values
    
    # Verifica se algum dos filmes recomendados está no df_teste e foi assistido (rating diferente de 0)
    for filme in recomendacoes:
        if filme in df_teste.columns and df_teste.loc[row['userId'], filme] != 0:
            return 1
        elif filme not in df_teste.columns:
            return 2
        #else:
        #    return 0
    # Se nenhum filme recomendado foi assistido, retorna 0
    return 0    

# Aplicar a função a cada linha do DataFrame de recomendações para criar a coluna dummy
df_recomendacoes['assistiu_recomendacao'] = df_recomendacoes.apply(assistiu_ou_nao, df_teste=knn_filmes_teste, axis=1)
df_recomendacoes

df_recomendacoes['assistiu_recomendacao'].value_counts()